home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Misc / msql-1.0.6 / src / regexp / timer.c < prev    next >
C/C++ Source or Header  |  1994-06-29  |  4KB  |  186 lines
  1. /*
  2.  * Simple timing program for regcomp().
  3.  *
  4.  *    Copyright (c) 1986 by University of Toronto.
  5.  *    Written by Henry Spencer.  Not derived from licensed software.
  6.  *
  7.  *    Permission is granted to anyone to use this software for any
  8.  *    purpose on any computer system, and to redistribute it freely,
  9.  *    subject to the following restrictions:
  10.  *
  11.  *    1. The author is not responsible for the consequences of use of
  12.  *        this software, no matter how awful, even if they arise
  13.  *        from defects in it.
  14.  *
  15.  *    2. The origin of this software must not be misrepresented, either
  16.  *        by explicit claim or by omission.
  17.  *
  18.  *    3. Altered versions must be plainly marked as such, and must not
  19.  *        be misrepresented as being the original software.
  20.  *
  21.  * Usage: timer ncomp nexec nsub
  22.  *    or
  23.  *    timer ncomp nexec nsub regexp string [ answer [ sub ] ]
  24.  *
  25.  * The second form is for timing repetitions of a single test case.
  26.  * The first form's test data is a compiled-in copy of the "tests" file.
  27.  * Ncomp, nexec, nsub are how many times to do each regcomp, regexec,
  28.  * and regsub.  The way to time an operation individually is to do something
  29.  * like "timer 1 50 1".
  30.  */
  31. #include <stdio.h>
  32.  
  33. #include <common/portability.h>
  34.  
  35.  
  36. struct try {
  37.     char *re, *str, *ans, *src, *dst;
  38. } tests[] = {
  39. #include "timer.t.h"
  40. { NULL, NULL, NULL, NULL, NULL }
  41. };
  42.  
  43. #include <regexp.h>
  44.  
  45. int errreport = 0;        /* Report errors via errseen? */
  46. char *errseen = NULL;        /* Error message. */
  47.  
  48. char *progname;
  49.  
  50. /* ARGSUSED */
  51. main(argc, argv)
  52. int argc;
  53. char *argv[];
  54. {
  55.     int ncomp, nexec, nsub;
  56.     struct try one;
  57.     char dummy[512];
  58.  
  59.     if (argc < 4) {
  60.         ncomp = 1;
  61.         nexec = 1;
  62.         nsub = 1;
  63.     } else {
  64.         ncomp = atoi(argv[1]);
  65.         nexec = atoi(argv[2]);
  66.         nsub = atoi(argv[3]);
  67.     }
  68.     
  69.     progname = argv[0];
  70.     if (argc > 5) {
  71.         one.re = argv[4];
  72.         one.str = argv[5];
  73.         if (argc > 6)
  74.             one.ans = argv[6];
  75.         else
  76.             one.ans = "y";
  77.         if (argc > 7) {    
  78.             one.src = argv[7];
  79.             one.dst = "xxx";
  80.         } else {
  81.             one.src = "x";
  82.             one.dst = "x";
  83.         }
  84.         errreport = 1;
  85.         try(one, ncomp, nexec, nsub);
  86.     } else
  87.         multiple(ncomp, nexec, nsub);
  88.     exit(0);
  89. }
  90.  
  91. void
  92. regerror(s)
  93. char *s;
  94. {
  95.     if (errreport)
  96.         errseen = s;
  97.     else
  98.         error(s, "");
  99. }
  100.  
  101. #ifndef ERRAVAIL
  102. error(s1, s2)
  103. char *s1;
  104. char *s2;
  105. {
  106.     fprintf(stderr, "regexp: ");
  107.     fprintf(stderr, s1, s2);
  108.     fprintf(stderr, "\n");
  109.     exit(1);
  110. }
  111. #endif
  112.  
  113. int lineno = 0;
  114.  
  115. multiple(ncomp, nexec, nsub)
  116. int ncomp, nexec, nsub;
  117. {
  118.     register int i;
  119.     extern char *strchr();
  120.  
  121.     errreport = 1;
  122.     for (i = 0; tests[i].re != NULL; i++) {
  123.         lineno++;
  124.         try(tests[i], ncomp, nexec, nsub);
  125.     }
  126. }
  127.  
  128. try(fields, ncomp, nexec, nsub)
  129. struct try fields;
  130. int ncomp, nexec, nsub;
  131. {
  132.     regexp *r;
  133.     char dbuf[BUFSIZ];
  134.     register int i;
  135.  
  136.     errseen = NULL;
  137.     r = regcomp(fields.re);
  138.     if (r == NULL) {
  139.         if (*fields.ans != 'c')
  140.             complain("regcomp failure in `%s'", fields.re);
  141.         return;
  142.     }
  143.     if (*fields.ans == 'c') {
  144.         complain("unexpected regcomp success in `%s'", fields.re);
  145.         free((char *)r);
  146.         return;
  147.     }
  148.     for (i = ncomp-1; i > 0; i--) {
  149.         free((char *)r);
  150.         r = regcomp(fields.re);
  151.     }
  152.     if (!regexec(r, fields.str)) {
  153.         if (*fields.ans != 'n')
  154.             complain("regexec failure in `%s'", "");
  155.         free((char *)r);
  156.         return;
  157.     }
  158.     if (*fields.ans == 'n') {
  159.         complain("unexpected regexec success", "");
  160.         free((char *)r);
  161.         return;
  162.     }
  163.     for (i = nexec-1; i > 0; i--)
  164.         (void) regexec(r, fields.str);
  165.     errseen = NULL;
  166.     for (i = nsub; i > 0; i--)
  167.         regsub(r, fields.src, dbuf);
  168.     if (errseen != NULL) {    
  169.         complain("regsub complaint", "");
  170.         free((char *)r);
  171.         return;
  172.     }
  173.     if (strcmp(dbuf, fields.dst) != 0)
  174.         complain("regsub result `%s' wrong", dbuf);
  175.     free((char *)r);
  176. }
  177.  
  178. complain(s1, s2)
  179. char *s1;
  180. char *s2;
  181. {
  182.     fprintf(stderr, "try: %d: ", lineno);
  183.     fprintf(stderr, s1, s2);
  184.     fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
  185. }
  186.